﻿//#include"MyString.h"
//#include<vector>
//#include<utility>
//
//
////struct Point
////{
////	int _x;
////	int _y;
////};
////class Date
////{
////public:
////	Date(int year = 1, int month = 1, int day = 1)
////		:_year(year)
////		, _month(month)
////		, _day(day)
////	{
////		std::cout << "Date(int year, int month, int day)" << std::endl;
////	}
////	Date(const Date& d)
////		:_year(d._year)
////		, _month(d._month)
////		, _day(d._day)
////	{
////		std::cout << "Date(const Date& d)" << std::endl;
////	}
////private:
////	int _year;
////	int _month;
////	int _day;
////};
//
//
//template<class T>
//void f1(T& x)
//{
//}
//
//template<class T>
//void f2(T&& x)
//{
//}
//
//typedef int& left;
//typedef int&& right;
//
//
//
//int main()
//{
//	int x = 0;
//	left& a=x; //左值
//	left&& b=x; //左值
//	right& c=x; //左值
//	right&& d=4; //右值
//
//	left& e=1;
//	left&& f=2;
//	right& g=3;
//	right&& h=x;
//
//	f1<int>(1); f1<int>(x); f1<int&>(1); f1<int&>(x); f1<int&&>(1); f1<int&&>(x);
//	f2<int>(1); f2<int>(x); f2<int&&>(1); f2<int&&>(x); f2<int&>(1); f2<int&>(x);
//
//	//int a = { 1 };
//	//int b{ 2 };
//	//Date x1 = { 2025,10,17 };
//	//Date x2{ 2025,10,17 };
//	////构造加拷贝构造直接优化成构造
//	//const Date& x3 = {2025,10,17};
//
//	//vector<int> x4{ 1,2,3,4,5,6,7 };
//	//vector<int> x5({ 1,2,3,4,5 });
//	//vector<int> x6 = { 1,2,3 };
//	//int y = 0;
//
//	//std::initializer_list<int> x = { 1,2,3,4,5,6,7,8 };
//	//cout << x.begin() << endl;
//	//cout << x.end() << endl;
//	//cout << x.end() - x.begin() << endl;
//
//
//
//	//int&& a = 10;
//
//	//int b = 0;
//	//int&& c = move(b);
//	//int&& d = (int&&)b;
//	//int&& e = b;
//
//	//std::string a = "aaaaaa";
//	//const std::string& b = a + "bbbbb";
//	//std::string&& c = a + b;
//	//std::string d = c;
//
//	//std::cout << a << std::endl;
//	//std::cout << b << std::endl;
//	//std::cout << d << std::endl;
//
//	////b = "ahds";
//	//c = "fskaj";
//
//
//	//int y = 0;
//
//	//A::MyString a = "aaaa";
//	//A::MyString b("bbbb");
//	//A::MyString c = A::MyString("cccc");
//	//A::MyString d = std::move(a);
//
//	//A::MyString a=A::addStrings("aaaa", "bbbb");
//
//
//	return 0;
//}


//#include <iostream>
//#include <utility> // 包含std::forward
//
//// 目标函数：区分左值和右值
//void process(int& x) { // 左值版本：处理需要保留的对象
//    std::cout << "处理左值：值为" << x << "，即将修改它\n";
//    x *= 2; // 修改左值（原对象会被影响）
//}
//
//void process(int&& x) { // 右值版本：处理可移动的临时对象
//    std::cout << "处理右值：值为" << x << "，这是临时对象\n";
//    // 右值是临时的，修改它不影响其他地方
//}
//
//// 中间转发函数：不用完美转发（错误示例）
//template <typename T>
//void wrap_process_bad(T&& param) {
//    std::cout << "[错误转发] 开始处理...\n";
//    // 直接传递param：此时param是有名字的左值（即使它绑定右值）
//    process(param);
//}
//
//// 中间转发函数：使用完美转发（正确示例）
//template <typename T>
//void wrap_process_good(T&& param) {
//    std::cout << "[完美转发] 开始处理...\n";
//    // 用std::forward<T>还原param的原始值类别
//    process(std::forward<T>(param));
//}
//
//int main() {
//    int a = 10; // 左值
//    std::cout << "=== 测试左值转发 ===\n";
//    wrap_process_bad(a);   // 错误转发：正确调用左值版本（因为a是左值）
//    wrap_process_good(a);  // 完美转发：正确调用左值版本
//    std::cout << "左值修改后：" << a << "\n\n"; // 验证a被修改
//
//    std::cout << "=== 测试右值转发 ===\n";
//    wrap_process_bad(20);  // 错误转发：右值被当作左值，调用左值版本（错误）
//    wrap_process_good(20); // 完美转发：正确调用右值版本（正确）
//
//    return 0;
//}
//#include"MyString.h"
#include<string>
#include<iostream>
#include<utility>
#include<list>

////下面我们用Args表示模板参数包，用args表示函数参数包
//template<class...Args>//模板参数包
//void Func1(Args...args) {}//函数参数包
//
//template<class...Args>
//void Func2(Args&...args) {}
//
//template<class...Args>
//void Func3(Args&&...args) {}
//
//template<class...Args>
//void print(Args&&...a)//万能引用接受各种类型的值
//{
//	std::cout << sizeof...(a) << std::endl;
//}
//
//int main()
//{
//	int x = 0;
//	print(x,1, "hadgauhs", 6.1,1+1);
//
//	return 0;
//}

using namespace std;
//int main()
//{
//	//list<string> lt;
//	//// 传左值，跟push_back⼀样，⾛拷⻉构造 
//	//string s1("111111111111");
//	//lt.emplace_back(s1);
//	//cout << "*********************************" << endl;
//	//// 右值，跟push_back⼀样，⾛移动构造 
//	//lt.emplace_back(move(s1));
//	//cout << "*********************************" << endl;
//	//// 直接把构造string参数包往下传，直接⽤string参数包构造string 
//	//// 这⾥达到的效果是push_back做不到的 
//	//lt.emplace_back("111111111111");
//	//cout << "*********************************" << endl;
//	//list<pair<string, int>> lt1;
//	//// 跟push_back⼀样 
//	//// 构造pair + 拷⻉/移动构造pair到list的节点中data上 
//	//pair<string, int> kv("苹果", 1);
//	//lt1.emplace_back(kv);
//	//cout << "*********************************" << endl;
//	//// 跟push_back⼀样 
//	//lt1.emplace_back(move(kv));
//	//cout << "*********************************" << endl;
//	//////////////////////////////////////////////////////////////////////
//	//// 直接把构造pair参数包往下传，直接⽤pair参数包构造pair 
//	//// 这⾥达到的效果是push_back做不到的 
//	//lt1.emplace_back("苹果", 1);
//	//cout << "*********************************" << endl;
//
//
//	return 0;
//}

//class Text
//{
//public:
//	//Text(int x)
//	//	:_a(10)
//	//{	}
//	//Text() = default;
//	Text() = delete;
//private:
//	int _a;
//};

	//auto t = [](double x, double y)->double {return x + y; };
	//cout << t(1.0, 2.0) << endl;
	//auto n = [](string x, string y)->string { return x+y; };
	//cout << n("aaa","bbb") << endl;
//auto fun1=[]{};
#include<functional>

//int main()
//{
//	int a = 0, b = 1, c = 2, d = 3;
//	auto fun1 = [a, &b]()->void
//		{ 
//			//只捕获a,b；c,d并没有被捕获也无法使用
//			//a++;  a为值捕捉不能被修改
//			b++;
//			cout << a + b << endl << "***************" << endl;
//			
//		};fun1();
//		
//	auto fun2 = [=]//返回类型被省略，同理由于不需要传参()也可以省略
//		{
//            //= 为隐式值捕获，被捕获对象不能被修改
//			//⽤了哪些变量就捕捉哪些变量 
//			cout << a + b+c+d << endl << "***************" << endl;
//			//返回值推断为void类型
//		}; fun2();
//
//	auto fun3 = [&]
//		{ 
//			//隐式引用捕获，被捕获对象可以被修改
//			//⽤了哪些变量就捕捉哪些变量 
//			a++;  
//			b++;
//			c++;
//			cout << a + b+c+d << endl << "***************" << endl;
//		};fun3();
//	
//	auto fun4 = [&,c]
//		{
//			//混合捕获，除了c明确为值捕获以外其它用到的变量为引用捕获
//			a++;
//			b++;
//			//c++;
//			cout << a + b+c+d << endl << "***************" << endl;
//		}; fun4();
//
//	auto fun5 = [=, &a]
//		{
//			//混合捕获，除了a明确为引用捕获以外其它用到的变量为值捕获
//			a++;
//			//b++;
//			//c++;
//			cout << a + b + c + d << endl << "***************" << endl;
//		}; fun5();
//	
//	return 0;
//}

int F1(int x, int y)
{
	return x + y;
}

struct F2
{
	int operator()(int x, int y)
	{
		return x + y;
	}
};

struct T
{
	static int F3(int x, int y)
	{
		return x + y;
	}
	int F4(int x, int y)
	{
		return x * y;
	}
};

int main()
{
	std::function<int(int, int)> f1 = &F1;//&显示传,函数指针
	std::function<int(int, int)> f2 = [](int x, int y)->int {return x + y; };
	std::function<int(int, int)> f3 = F2();

	//std::cout << f1(1, 2) << std::endl;
	//std::cout << f2(3, 4) << std::endl;
	//std::cout << f3(5, 6) << std::endl;

	//包装static静态成员函数
	//对于静态成员函数需要在类名前面取地址来获取函数指针
	std::function<int(int, int)> f4 = &T::F3;
	//std::cout << f4(7, 8) << std::endl;

	//包装普通成员函数
	//普通成员函数还有⼀个隐含的this指针参数，所以绑定时传对象或者对象的指针过去都可以 
	std::function<int(T*,int, int)> f5 = &T::F4;
	T text1;
	std::cout << f5(&text1,9, 10) << std::endl;

	std::function<int(T, int, int)> f6 = &T::F4;
	T text2;
	std::cout << f6(text2, 10, 10) << std::endl;

	return 0;
}